/**
 * 上传控制器 - 处理文件上传相关功能，支持base64转可读流上传
 */
const { Readable } = require('stream');

class UploadController {
  /**
   * 将base64数据转换为可读流并上传到云存储
   * @param {Object} event - 包含上传信息的事件对象
   * @param {string} [event.base64] - base64编码的文件数据
   * @param {string} [event.fileName] - 文件名
   * @param {string} [event.fileType] - 文件类型/扩展名
   * @param {string} [event.path] - 文件路径
   * @param {string} [event.filePath] - 文件路径（兼容旧接口）
   * @returns {Promise<Object>} 上传结果
   */
  async uploadFile(event) {
    console.log('uploadFile event:', event);

    try {
      // 提取必要参数
      const { base64, fileName, fileType } = event;

      let uploadResult;

      if (base64) {
        let base64Data = base64;
        if (base64Data.indexOf('base64,') > -1) {
          base64Data = base64Data.split('base64,')[1];
        }
        const cloudPath = `uploads/${fileName}`;

        // 6. 将base64转换为Buffer
        const buffer = Buffer.from(base64Data, 'base64');

        // 7. 将Buffer转换为可读流
        const readableStream = new Readable();
        readableStream._read = () => { }; // 实现_read方法
        readableStream.push(buffer);
        readableStream.push(null); // 结束流

        uploadResult = await uniCloud.uploadFile({
          cloudPath: cloudPath,
          fileContent: buffer // 使用Buffer直接上传，这是uniCloud支持的方式
        });
      } else {
        throw new Error('请提供base64数据或文件路径');
      }

      // 检查上传结果
      if (uploadResult && uploadResult.fileID) {
        let result = await uniCloud.getTempFileURL({
          fileList: [uploadResult.fileID]
        });
        uploadResult.url = result.fileList[0].tempFileURL;
        return {
          code: 200,
          message: '文件上传成功',
          data: uploadResult
        };
      } else {
        throw new Error('上传失败，未获取到fileID');
      }
    } catch (error) {
      console.error('base64ToStreamUpload error:', error);
      return {
        code: 500,
        message: '文件上传失败: ' + error.message,
        error: error.message
      };
    }
  }

  /**
   * 批量上传base64文件
   * @param {Object} event - 包含上传信息的事件对象
   * @param {Array} event.files - 文件数组，每项包含base64、fileName、fileType
   * @returns {Promise<Object>} 批量上传结果
   */
  async batchUploadFile(event) {
    console.log('batchUploadFile event:', event);

    try {
      const { files } = event;

      if (!Array.isArray(files)) {
        throw new Error('files参数必须是数组');
      }

      if (files.length === 0) {
        return {
          code: 200,
          message: '未上传任何文件',
          data: {
            successList: [],
            failList: []
          }
        };
      }

      // 限制批量上传数量
      if (files.length > 10) {
        throw new Error('单次批量上传文件数量不能超过10个');
      }

      const successList = [];
      const failList = [];

      // 并行上传所有文件
      const uploadPromises = files.map(async (file, index) => {
        try {
          const result = await this.base64ToStreamUpload({
            base64: file.base64,
            fileName: file.fileName,
            fileType: file.fileType
          });

          if (result.code === 200) {
            successList.push({
              index,
              ...result.data
            });
          } else {
            failList.push({
              index,
              error: result.message
            });
          }
        } catch (error) {
          failList.push({
            index,
            error: error.message
          });
        }
      });

      // 等待所有上传完成
      await Promise.all(uploadPromises);

      return {
        code: 200,
        message: `批量上传完成，成功${successList.length}个，失败${failList.length}个`,
        data: {
          successList,
          failList,
          total: files.length,
          successCount: successList.length,
          failCount: failList.length
        }
      };
    } catch (error) {
      console.error('batchBase64Upload error:', error);
      return {
        code: 500,
        message: '批量上传失败: ' + error.message,
        error: error.message
      };
    }
  }
}

module.exports = { UploadController };